{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=6>K近邻法(KNN)算法</font>\n",
    "# 概述\n",
    "## K近邻法(k-nearest neighbors,KNN)：\n",
    "1. 基本的监督学习方法；\n",
    "2. 既可以做分类，也可以做回归；\n",
    "3. 通俗原理：近朱者赤近墨者黑；\n",
    "\n",
    "## KNN做回归和分类的主要区别在于最后做预测时候的决策方式不同\n",
    "1. KNN做分类预测时，一般是选择多数表决法，即训练集里和预测的样本特征最近的K个样本，预测为里面有最多类别数的类别；\n",
    "2. KNN做回归时，一般是选择平均法，即最近的K个样本的样本输出的平均值作为回归预测值；\n",
    "\n",
    "## KNN在scikit-learn中的实现方式\n",
    "1. 蛮力实现(brute-force)；\n",
    "2. KD树实现(KDTree)；\n",
    "3. 球树(BallTree)；\n",
    "\n",
    "**其他实现方式：**BBF树，MVP树等；"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN算法三要素\n",
    "1. k值的选取\n",
    "2. 距离度量的方式\n",
    "3. 分类决策规则\n",
    "\n",
    "## k值的选取\n",
    "对于k值的选择，没有一个固定的经验，一般根据样本的分布，选择一个较小的值，可以通过交叉验证选择一个合适的k值。\n",
    "\n",
    "选择较小的k值，就相当于用较小的领域中的训练实例进行预测，训练误差会减小，只有与输入实例较近或相似的训练实例才会对预测结果起作用，与此同时带来的问题是泛化误差会增大，换句话说，K值的减小就意味着整体模型变得复杂，容易发生过拟合；\n",
    "\n",
    "选择较大的k值，就相当于用较大领域中的训练实例进行预测，其优点是可以减少泛化误差，但缺点是训练误差会增大。这时候，与输入实例较远（不相似的）训练实例也会对预测起作用，使预测发生错误，且K值的增大就意味着整体的模型变得简单。\n",
    "\n",
    "\n",
    "一个极端是k等于样本数m，则完全没有分类，此时无论输入实例是什么，都只是简单的预测它属于在训练实例中最多的类，模型过于简单。\n",
    "## 距离度量的方式\n",
    "闵可夫斯基距离(Minkowski Distance)，定义为：\n",
    "$$\\large D(x,y) =\\sqrt[p]{(|x_1-y_1|)^p + (|x_2-y_2|)^p + ... + (|x_n-y_n|)^p} =\\sqrt[p]{\\sum\\limits_{i=1}^{n}(|x_i-y_i|)^p}$$\n",
    "\n",
    "当p=1时，又叫曼哈顿距离；\n",
    "\n",
    "当p=2时，又叫欧式距离（比较常用）；\n",
    "## 分类决策规则\n",
    "一般都是使用前面提到的多数表决法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 蛮力实现\n",
    "## 原理\n",
    "1. 假设有一个带有标签的样本数据集（训练样本集），其中包含每条数据与所属分类的对应关系。\n",
    "2. 输入没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较。\n",
    "    1. 计算新数据与样本数据集中每条数据的距离。\n",
    "    2. 对求得的所有距离进行排序（从小到大，越小表示越相似）。\n",
    "    3. 取前 k （k 一般小于等于 20 ）个样本数据对应的分类标签。\n",
    "3. 求 k 个数据中出现次数最多的分类标签作为新数据的分类。\n",
    "\n",
    "## 总结\n",
    "该方法简单直接，在样本量少，样本特征少的时候有效。\n",
    "\n",
    "但是碰到样本的特征数有上千以上，样本量有几十万以上，预测少量的测试集样本，这时候，算法的时间效率很成问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KD树实现\n",
    "KD树算法包括三步：\n",
    "1. 第一步是建树；\n",
    "2. 第二步是搜索最近邻；\n",
    "3. 最后一步是预测。\n",
    "\n",
    "## KD树的建立\n",
    "KD树建树采用的是从$m$个样本的$n$维特征中，分别计算$n$个特征的取值的方差，用方差最大的第$k$维特征$n_k$来作为根节点。对于这个特征，我们选择特征$n_k$的取值的中位数$n_{kv}$对应的样本作为划分点，对于所有第k维特征的取值小于$n_{kv}$的样本，我们划入左子树，对于第$k$维特征的取值大于等于$n_{kv}$的样本，我们划入右子树，对于左子树和右子树，我们采用和刚才同样的办法来找方差最大的特征来做根节点，递归的生成KD树。\n",
    "\n",
    "具体流程如下图：\n",
    "<img src=\"images/1042406-20161114150258701-1426435920.jpg\">\n",
    "\n",
    "### 例\n",
    "比如我们有二维样本6个，{(2,3)，(5,4)，(9,6)，(4,7)，(8,1)，(7,2)}，构建kd树的具体步骤为：\n",
    "1. 找到划分的特征。6个数据点在x，y维度上的数据方差分别为6.97，5.37，所以在x轴上方差更大，用第1维特征建树。\n",
    "2. 确定划分点(7,2)。根据x维上的值将数据排序，6个数据的中值为7，所以划分点的数据是（7,2）。这样，该节点的分割超平面就是通过（7,2）的直线x=7；\n",
    "3. 确定左子空间和右子空间。 分割超平面x=7将整个空间分为两部分：x<7的部分为左子空间，包含3个节点={(2,3),(5,4),(4,7)}；另一部分为右子空间，包含3个节点={(7,2)，(9,6)，(8,1)}。\n",
    "4. 用同样的办法划分左子树的节点{(2,3),(5,4),(4,7)}和右子树的节点{(7,2)，(9,6)，(8,1)}。最终得到KD树。\n",
    "\n",
    "<img src=\"images/1042406-20161114151317201-1936126361.jpg\">\n",
    "\n",
    "## KD树搜索最近邻\n",
    "对于一个目标点(测试数据)，搜索流程：\n",
    "1. 首先在KD树里面找到包含目标点的叶子节点；\n",
    "2. 以目标点为圆心，以目标点到叶子节点样本实例的距离为半径，得到一个超球体，最近邻的点一定在这个超球体内部；\n",
    "3. 返回叶子节点的父节点，检查另一个子节点包含的超矩形体是否和超球体相交；\n",
    "    1. 如果相交就到这个子节点寻找是否有更加近的近邻,有的话就更新最近邻；\n",
    "    2. 如果不相交那就简单了，我们直接返回父节点的父节点，在另一个子树继续搜索最近邻；\n",
    "4. 当回溯到根节点时，算法结束，此时保存的最近邻节点就是最终的最近邻。\n",
    "\n",
    "KD树划分后可以大大减少无效的最近邻搜索，很多样本点由于所在的超矩形体和超球体不相交，根本不需要计算距离。大大节省了计算时间。\n",
    "\n",
    "### 例\n",
    "我们用上面建立KD树的例子，来看测试数据（目标点）**(2,4.5)**找最近邻的过程:\n",
    "1. 确定叶子节点：<(7,2)，(5,4)，(4,7)>\n",
    "2. 获取超球体，得到最近邻为(2,3)叶子节点\n",
    "3. 向上回溯父节点<(2,3),(5,4),(7,2)>\n",
    "4. 确定第一个最近邻点为（2,3）\n",
    "\n",
    "<img src=\"images/1042406-20161114165145763-428195796.jpg\">\n",
    "\n",
    "## KD树预测\n",
    "根据上面搜索到的K个最近邻，按照多数表决法：\n",
    "1. 如果是KNN分类，预测为K个最近邻里面有最多类别数的类别；\n",
    "2. 如果是KNN回归，用K个最近邻样本输出的平均值作为回归预测值；"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN球树实现\n",
    "KD树算法虽然提高了KNN搜索的效率，但是在某些时候效率并不高，比如当处理不均匀分布的数据集时,不管是近似方形，还是矩形，甚至正方形，都不是最好的使用形状，因为他们都有角。\n",
    "\n",
    "**例如：**\n",
    "<img src=\"images/1042406-20161114171107045-1904406302.jpg\">\n",
    "如果黑色的实例点离目标点星点再远一点，那么虚线圆会如红线所示那样扩大，导致与左上方矩形的右下角相交，既然相 交了，那么就要检查这个左上方矩形，而实际上，最近的点离星点的距离很近，检查左上方矩形区域已是多余。\n",
    "\n",
    "球树建树可以优化这种问题。\n",
    "## 球树的建立\n",
    "球树，顾名思义，就是每个分割块都是超球体，而不是KD树里面的超矩形体。\n",
    "<img src=\"images/1042406-20161114172004185-213758204.jpg\">\n",
    "\n",
    "**建树流程：**\n",
    "1. 先构建一个超球体，这个超球体包含所有样本的最小球体；\n",
    "2. 从球中选择一个离球的中心最远的点，然后选择第二个点离第一个点最远，将球中所有的点分配到离这两个聚类中心最近的一个上，然后计算每个聚类的中心，以及聚类能够包含它所有数据点所需的最小半径。这样我们得到了两个子超球体，这和KD树里面的左右子树对应；\n",
    "3. 对于这两个子超球体，递归执行步骤2；最终得到球树；\n",
    "\n",
    "## 球树搜索最近邻\n",
    "**流程：**\n",
    "1. 首先自上而下贯穿整棵树找出包含目标点所在的叶子，并在这个球里找出与目标点最邻近的点，这将确定出目标点距离它的最近邻点的一个上限值；\n",
    "2. 跟KD树查找一样，检查兄弟结点：\n",
    "    1. 如果目标点到兄弟结点中心的距离超过兄弟结点的半径与当前的上限值之和，那么兄弟结点里不可能存在一个更近的点；\n",
    "    2. 否则的话，必须进一步检查位于兄弟结点以下的子树；\n",
    "3. 检查完兄弟节点后，我们向父节点回溯，继续搜索最小邻近值。当回溯到根节点时，此时的最小邻近值就是最终的搜索结果；\n",
    "\n",
    "**特点：**\n",
    "\n",
    "KD树在搜索路径优化时使用的是两点之间的距离来判断，而球树使用的是两边之和大于第三边来判断，相对来说球树的判断更加复杂，但是却避免了更多的搜索，这是一个权衡。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN算法的扩展\n",
    "## 限定半径\n",
    "样本中某系类别的样本非常的少，甚至少于K，这导致稀有类别样本在找K个最近邻的时候，会把距离其实较远的其他样本考虑进来，而导致预测不准确。为了解决这个问题，我们限定最近邻的一个最大距离，也就是说，我们只在一个距离范围内搜索所有的最近邻，这个距离我们一般称为限定半径。\n",
    "## 质心算法\n",
    "质心算法比KNN还简单。它首先把样本按输出类别归类。对于第$L$类的$C_l$个样本。它会对这$C_l$个样本的$n$维特征中每一维特征求平均值，最终该类别所有维度的$n$个平均值形成所谓的质心点。对于样本中的所有出现的类别，每个类别会最终得到一个质心点。当我们做预测时，仅仅需要比较预测样本和这些质心的距离，最小的距离对于的质心类别即为预测的类别。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN算法总结\n",
    "## KNN的主要优点有：\n",
    "\n",
    "1. 理论成熟，思想简单，既可以用来做分类也可以用来做回归\n",
    "2. 可用于非线性分类\n",
    "3. 训练时间复杂度比支持向量机之类的算法低，仅为O(n)\n",
    "4. 和朴素贝叶斯之类的算法比，对数据没有假设，准确度高，对异常点不敏感\n",
    "5. 由于KNN方法主要靠周围有限的邻近的样本，而不是靠判别类域的方法来确定所属类别的，因此对于类域的交叉或重叠较多的待分样本集来说，KNN方法较其他方法更为适合\n",
    "6. 该算法比较适用于样本容量比较大的类域的自动分类，而那些样本容量较小的类域采用这种算法比较容易产生误分\n",
    "\n",
    "\n",
    "## KNN的主要缺点有：\n",
    "\n",
    "1. 计算量大，尤其是特征数非常多的时候\n",
    "2. 样本不平衡的时候，对稀有类别的预测准确率低\n",
    "3. KD树，球树之类的模型建立需要大量的内存\n",
    "4. 使用懒散学习方法，基本上不学习，导致预测时速度比起逻辑回归之类的算法慢\n",
    "5. 相比决策树模型，KNN模型可解释性不强\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# scikit-learn 中KNN相关的类库\n",
    "在scikit-learn 中，与近邻法这一大类相关的类库都在sklearn.neighbors包之中。\n",
    "1. KNN分类树的类是KNeighborsClassifier\n",
    "2. KNN回归树的类是KNeighborsRegressor\n",
    "3. 限定半径最近邻分类树的类RadiusNeighborsClassifier\n",
    "4. 限定半径最近邻回归树的类RadiusNeighborsRegressor\n",
    "5. 最近质心分类算法NearestCentroid\n",
    "\n",
    "**参数：**\n",
    "1. n_neighbors：KNN中的K值\n",
    "1. radius：限定半径最近邻法中的半径\n",
    "1. weights：近邻权重\n",
    "1. algorithm：KNN和限定半径最近邻法使用的算法\n",
    "1. leaf_size：停止建子树的叶子节点阈值\n",
    "1. metric：距离度量算法\n",
    "1. p：距离度量附属参数\n",
    "1. metric_params：距离度量其他附属参数\n",
    "1. n_jobs：并行处理任务数\n",
    "1. outlier_label：异常点类别选择\n",
    "\n",
    "另外，几个在sklearn.neighbors包中但不是做分类回归预测的类也值得关注\n",
    "1. kneighbors_graph类返回用KNN时和每个样本最近的K个训练集样本的位置；\n",
    "2. radius_neighbors_graph返回用限定半径最近邻法时和每个样本在限定半径内的训练集样本的位置；\n",
    "3. NearestNeighbors为无监督最近邻，它即可以返回用KNN时和每个样本最近的K个训练集样本的位置，也可以返回用限定半径最近邻法时和每个样本最近的训练集样本的位置，它常常用在聚类模型中；\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 使用KNeighborsClassifier做分类的实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from sklearn.datasets.samples_generator import make_classification\n",
    "# X为样本特征，Y为样本类别输出， 共1000个样本，每个样本2个特征，输出有3个类别，没有冗余特征，每个类别一个簇\n",
    "X, Y = make_classification(n_samples=1000, n_features=2, n_redundant=0,\n",
    "                             n_clusters_per_class=1, n_classes=3,random_state=6)\n",
    "plt.scatter(X[:, 0], X[:, 1], marker='o', c=Y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=None, n_neighbors=15, p=2,\n",
       "           weights='distance')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import neighbors\n",
    "clf = neighbors.KNeighborsClassifier(n_neighbors = 15 , weights='distance')\n",
    "clf.fit(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, \"3-Class classification (k = 15, weights = 'distance')\")"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF'])\n",
    "cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])\n",
    "\n",
    "#确认训练集的边界\n",
    "x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n",
    "y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n",
    "#生成随机数据来做测试集，然后作预测\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),\n",
    "                         np.arange(y_min, y_max, 0.02))\n",
    "Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n",
    "\n",
    "# 画出测试集数据\n",
    "Z = Z.reshape(xx.shape)\n",
    "plt.figure()\n",
    "plt.pcolormesh(xx, yy, Z, cmap=cmap_light)\n",
    "\n",
    "# 也画出所有的训练集数据\n",
    "plt.scatter(X[:, 0], X[:, 1], c=Y, cmap=cmap_bold)\n",
    "plt.xlim(xx.min(), xx.max())\n",
    "plt.ylim(yy.min(), yy.max())\n",
    "plt.title(\"3-Class classification (k = 15, weights = 'distance')\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
